/**
 * 项目管理器
 * 负责项目的创建、加载、保存等操作
 */

import { Project } from '../types/Project';
import { globalPlayer } from 'python-player';
import { defaultProject } from '../constants/default-project/index.js';
import { getProjectVersion } from './version';

class ProjectManager {
  constructor() {
    this.currentProject = null;
    this.isInitialized = false;
  }

  /**
   * 初始化项目管理器
   */
  async initialize() {
    if (this.isInitialized) return;

    try {
      // 创建默认项目（包含文件系统初始化）
      this.currentProject = await this.createNewProject();
      
      this.isInitialized = true;
      console.log('项目管理器初始化完成');
    } catch (error) {
      console.error('项目管理器初始化失败:', error);
      throw error;
    }
  }

  async createNewProject(options = {}) {
    // 合并默认配置和用户选项
    const projectOptions = { ...defaultProject, ...options };
    const project = new Project(projectOptions);
    
    // 重新加载文件到文件系统
    await globalPlayer.init(projectOptions.files);
    
    // 设置项目对fs的引用
    project.setFileSystem(globalPlayer.fs);
    
    this.currentProject = project;
    return project;
  }

  /**
   * 获取当前项目
   */
  getCurrentProject() {
    return this.currentProject;
  }


  /**
   * 加载项目
   */
  async loadProject(projectData) {
    const project = Project.fromJSON(projectData);
    
    // 如果有导入的文件数据，重新加载文件到文件系统
    if (project._importFiles && project._importFiles.length > 0) {
      // 直接使用 init 方法加载新文件
      await globalPlayer.init(project._importFiles);
      
      // 清理临时数据
      delete project._importFiles;
    }
    
    // 设置项目对fs的引用
    project.setFileSystem(globalPlayer.fs);
    
    this.currentProject = project;
    return project;
  }

  /**
   * 保存项目
   */
  async saveProject() {
    try {
      if (!this.currentProject) {
        return { success: false, error: '没有当前项目可保存' };
      }

      // 由于编辑器内容已经自动保存到文件系统，这里只需要保存项目配置
      await this.saveProjectToServer(this.currentProject);
      
      this.currentProject.markSaved();
      
      console.log('项目保存成功:', this.currentProject.name);
      
      return { 
        success: true, 
        message: '项目保存成功'
      };
    } catch (error) {
      console.error('项目保存失败:', error);
      return { 
        success: false, 
        error: error.message,
        message: `项目保存失败: ${error.message}`
      };
    }
  }

  /**
   * 保存项目到服务器
   */
  async saveProjectToServer(project) {
    try {
      const projectData = project.toJSON();
      
      // TODO: 实现服务器保存逻辑
      // 这里将来会调用 API 将项目数据保存到服务器
      console.log('准备保存到服务器:', projectData);
      
      // 示例 API 调用（将来实现）:
      // const response = await fetch('/api/projects/save', {
      //   method: 'POST',
      //   headers: { 'Content-Type': 'application/json' },
      //   body: JSON.stringify(projectData)
      // });
      // 
      // if (!response.ok) {
      //   throw new Error('服务器保存失败');
      // }
      
    } catch (error) {
      console.error('保存到服务器失败:', error);
      // 注意：这里不抛出错误，避免影响本地文件系统同步
    }
  }



  /**
   * 创建新文件
   */
  async createFile(name, content = '', type = 'python', parentId = 0) {
    if (!this.currentProject) {
      throw new Error('没有当前项目');
    }

    // 根据文件扩展名或类型确定 mimeType
    let mimeType = 'text/plain';
    if (type === 'python' || name.endsWith('.py')) {
      mimeType = 'text/x-python';
    } else if (type === 'json' || name.endsWith('.json')) {
      mimeType = 'application/json';
    }

    // 使用通用的 createFile 方法
    const file = await globalPlayer.fs.createFile(name, {
      content,
      mimeType,
      parentId
    });
    
    return file;
  }

  /**
   * 创建新文件夹
   */
  async createFolder(name, parentId = 0) {
    if (!this.currentProject) {
      throw new Error('没有当前项目');
    }

    // 使用文件系统的 createDirectory 方法
    const folder = await globalPlayer.fs.createDirectory(name, parentId, false);
    
    return folder;
  }

  /**
   * 删除文件或文件夹
   */
  async deleteFile(fileId) {
    if (!this.currentProject) return false;

    const item = globalPlayer.fs.getItem(fileId);
    if (!item) return false;

    try {
      // 根据类型调用相应的删除方法
      if (item.type === 'directory') {
        // 删除文件夹（递归删除所有子项）
        globalPlayer.fs.deleteDirectory(fileId);
        console.log(`文件夹删除成功: ${item.name} (ID: ${fileId})`);
      } else if (item.type === 'file') {
        // 删除文件
        globalPlayer.fs.deleteFile(fileId);
        console.log(`文件删除成功: ${item.name} (ID: ${fileId})`);
      } else {
        console.error('未知的文件类型:', item);
        return false;
      }
      
      return true;
    } catch (error) {
      console.error('删除失败:', error);
      return false;
    }
  }

  /**
   * 运行当前文件
   */
  async runCurrentFile() {
    if (!this.currentProject) {
      throw new Error('没有当前项目');
    }

    // 这个方法现在由 projectStore 调用，不需要在这里实现
    // 实际的运行逻辑在 projectStore.runCurrentFile 中
    throw new Error('runCurrentFile 应该在 projectStore 中调用');
  }

  /**
   * 停止运行
   */
  async stopRunning() {
    await globalPlayer.stop();
  }

  /**
   * 导出项目
   */
  async exportProject(options = {}) {
    if (!this.currentProject) {
      throw new Error('没有当前项目');
    }

    return await this.currentProject.export(options);
  }

  /**
   * 导出项目为JSON格式（包含完整文件数据）
   */
  async exportProjectAsJSON() {
    try {
      if (!this.currentProject) {
        return { success: false, error: '没有当前项目' };
      }

      // 由于编辑器内容已经自动保存到文件系统，直接导出即可
      
      // 获取项目基本信息
      const projectData = this.currentProject.toJSON();
      
      // 使用文件系统的toJSON方法获取所有文件数据
      const fsData = await this.currentProject.fs.toJSON({ includeContent: true });

      // 构建完整的项目数据
      const completeProjectData = {
        ...projectData,
        files: fsData.files,
        statistics: fsData.statistics,
        fileSystemInfo: fsData.fileSystemInfo
      };

      const jsonString = JSON.stringify(completeProjectData, null, 2);
      
      // 统计文件和目录数量
      const fileCount = fsData.files.filter(item => item.type === 'file').length;
      const directoryCount = fsData.files.filter(item => item.type === 'directory').length;
      
      return {
        success: true,
        data: jsonString,
        projectName: this.currentProject.name,
        fileCount,
        directoryCount
      };
    } catch (error) {
      console.error('导出项目为JSON失败:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  /**
   * 导入项目
   */
  async importProject(fileContent, options = {}) {
    const project = await Project.import(fileContent, options);
    
    // 如果有导入的文件数据，重新加载文件到文件系统
    if (project._importFiles && project._importFiles.length > 0) {
      // 直接使用 init 方法加载新文件
      await globalPlayer.init(project._importFiles);
      
      // 清理临时数据
      delete project._importFiles;
    }
    
    // 设置项目对fs的引用
    project.setFileSystem(globalPlayer.fs);
    
    this.currentProject = project;
    return project;
  }

  /**
   * 获取项目统计信息
   */
  getProjectStats() {
    if (!this.currentProject) return null;

    const files = this.currentProject.getAllFiles();
    const pythonFiles = this.currentProject.getPythonFiles();
    
    return {
      totalFiles: files.length,
      pythonFiles: pythonFiles.length,
      totalSize: files.reduce((sum, file) => sum + file.size, 0),
      lastModified: this.currentProject.lastModified,
      isDirty: this.currentProject.isDirty
    };
  }
}

// 创建全局实例
const projectManager = new ProjectManager();

export default projectManager;
